The following content has been provided by the University of Erlangen-Nürnberg.

Thank you for the introduction and thanks for having me here. I want to go ahead and

pick an application topic basically or looking at organic computing from an application point

of view because I believe that is an interesting opportunity to look at some of the more general

problems with having a particular application in mind. And obviously most of us are familiar

with vehicular traffic and problems we all have with vehicular traffic. So I thought

that would be an interesting opportunity and an interesting topic to talk about. But first

of all a few words who we are in Augsburg. So Professor Teich already mentioned it. The

chair has been founded in January 2012. Currently that's me. Two post-docs, one of which is

here today, that's Sebastian. On the occasion he came with me to have a look at the talk

as well. Then there's Sven Tom Forde, those of you who are familiar with the former priority

program in organic computing might have heard of him. And so we also have five PhD students

currently. And the research focus would be on intelligent embedded systems which are

capable of learning and self-organizing. So we're not so much the hardware level guys

as most of you probably are. We're looking more at it from a software perspective and

at a networking perspective and want to make them better by having them self-organized

so you as a user don't have to care about many things and don't have to set up. And

we do also application driven research in a variety of application domains. We are working

on so-called smart camera networks or intelligent video surveillance network camera systems,

sensor actuator systems, whatever you want to call it. We also work on making data communication

better by self-organizing or self-optimizing communication protocols. I'm not going to

talk about these two topics today. I'm going to focus on the issue of traffic control in

the sense of vehicular traffic that is. So not to mix up with the data communication

stuff. And the overall goal would be to develop highly robust adaptive and self-optimizing

systems. And we see a few examples of that soon. So that is a slide probably some of

you have seen before but nevertheless I want to start with it. So the development we've

gone through is across the past decades we had like 50 years ago roughly one computer

serving many people. Then it went on to the PC area where you had one computer per person.

And nowadays, well count the number of cores you might have on your desk and in your pockets.

Most of us have many computers on one person. So at the same time we saw the size of the

computers obviously decreasing. I've got my multi-core in my pocket. Hopefully it doesn't

bother me while I'm giving the talk. And so we can carry them around with us and don't

have to have huge rooms with them. And the number increased obviously. So we're in the

situation that we rather have the problem of putting them all together, networking them.

Most of us had the experience that if you bring a new device into a new environment

and try to connect it with whatever you might run into problems. So the user might be rather

confused and that's really an issue in many disciplines and many areas to get hold of

that situation and get things going in an environment with a high number of computers

per person which are in a sense networked or we want them to be networked. So a couple

of observations. We see malfunctions and outages due to the high complexity. So we have to

especially look at the interconnectedness of the subsystems basically. In particular

that is the way we look at it because of unknown configuration and situation spaces because

you might bring an arbitrary set of devices into an environment the developers have never

thought about being put together in the same situation. So we've got, we experience dynamic

environments and we can't really anticipate all the possible situations which might come

during the runtime of the systems at design time. So we have to take care and redesign

systems, think of new ways of designing systems in such a way that they can cope with these

problems at runtime. So they have to be somehow self-organizing at runtime and we can't like

send always a developer with the system to take care of it and redevelop it and reconnect

it and reprogram it, change parameters. So we want the, essentially we want the system